<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 skin-theme-clientpref-day vector-sticky-header-enabled" lang="de" dir="ltr"><head>
<meta charset="UTF-8">
<title>F-Sharp</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://de.wikipedia.org/wiki/F-Sharp"> <link href="./_mw_/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link href="./_mw_/ext.gadget.citeRef.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.defaultPlainlinks.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonHide.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonLayout.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonStyle.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiDarkmode.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiResponsive.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.specialSearch.css" rel="stylesheet" type="text/css">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-F-Sharp rootpage-F-Sharp skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">F-Sharp</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr">
<table class="float-right infobox toccolours toptextcells" style="font-size:90%; margin-top:0; width:21em;">
<tbody><tr>
<th colspan="2" class="hintergrundfarbe6" style="font-size:larger;">F#
</th></tr>
<tr>
<td colspan="2" class="notheme" style="text-align:center; background-color:#f8f9fa;"><span typeof="mw:File"></span>
</td></tr>
<tr>
<th colspan="2" class="hintergrundfarbe5" style="font-size:105%; text-align:center;">Basisdaten
</th></tr>
<tr>
<td><b><a href="Programmierparadigma" title="Programmierparadigma">Paradigmen</a>:</b>
</td>
<td>multiparadigmatisch: <a href="Funktionale_Programmierung" title="Funktionale Programmierung">funktional</a>, <a href="Imperative_Programmierung" title="Imperative Programmierung">imperativ</a>, <a href="Objektorientierte_Programmierung" title="Objektorientierte Programmierung">objektorientiert</a>
</td></tr>
<tr>
<td><b>Erscheinungsjahr:</b>
</td>
<td>2002
</td></tr>
<tr>
<td><b>Designer:</b>
</td>
<td><span class="wikidata-content">Don Syme, <a href="Microsoft_Research" title="Microsoft Research">Microsoft Research</a></span>
</td></tr>
<tr>
<td><b>Entwickler:</b>
</td>
<td>F Sharp Software Foundation, Don Syme, <a href="Microsoft" title="Microsoft">Microsoft</a>,
</td></tr>
<tr>
<td><b>Aktuelle <a href="Version_(Software)" title="Version (Software)">Version</a>:</b>
</td>
<td style="white-space:nowrap;">7.0<sup id="cite_ref-1" class="reference"><a href="#cite_note-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup> <small>(8. November 2022)</small>
</td></tr>
<tr>
<td><b><a href="Typisierung_(Informatik)" title="Typisierung (Informatik)">Typisierung</a>:</b>
</td>
<td><a href="Statische_Typisierung" title="Statische Typisierung">statisch</a>, <a href="Starke_Typisierung" title="Starke Typisierung">stark</a>, implizit
</td></tr>
<tr>
<td><b>Beeinflusst von:</b>
</td>
<td><a href="Objective_CAML" class="mw-redirect" title="Objective CAML">Objective CAML</a>, <a href="C-Sharp" title="C-Sharp">C#</a>, <a href="Haskell_(Programmiersprache)" title="Haskell (Programmiersprache)">Haskell</a>, <a href="Elm_(Programmiersprache)" title="Elm (Programmiersprache)">Elm</a>
</td></tr>
<tr>
<td><b>Beeinflusste:</b>
</td>
<td><a href="Elm_(Programmiersprache)" title="Elm (Programmiersprache)">Elm</a>, F*, <a href="LiveScript" class="mw-redirect" title="LiveScript">LiveScript</a>, <a href="Elixir_(Programmiersprache)" title="Elixir (Programmiersprache)">Elixir </a>
</td></tr>
<tr>
<td><b><a href="Betriebssystem" title="Betriebssystem">Betriebssystem</a>:</b>
</td>
<td><a href="Plattform%C3%BCbergreifend" class="mw-redirect" title="Plattformübergreifend">plattformübergreifend</a>
</td></tr>
<tr>
<td><b><a href="Lizenz" title="Lizenz">Lizenz</a>:</b>
</td>
<td><a href="Apache-Lizenz_2.0" class="mw-redirect" title="Apache-Lizenz 2.0">Apache-Lizenz 2.0</a>
</td></tr>
<tr>
<td colspan="2" class="hintergrundfarbe5" style="text-align:center;"><a rel="nofollow" class="external text" href="http://fsharp.org/">F# Software Foundation</a>
</td></tr></tbody></table>
<p><b>F#</b> (gelesen: <i>F <span lang="en">sharp</span></i>; englische Aussprache [<style data-mw-deduplicate="TemplateStyles:r227981795">
/* start https://de.wikipedia.org/ */
.mw-parser-output .IPA a{text-decoration:none}
/* end https://de.wikipedia.org/ */
</style><span class="navigation-not-searchable"><span class="IPA"><a href="Liste_der_IPA-Zeichen" title="Liste der IPA-Zeichen"><span title="Aussprache im Internationalen Phonetischen Alphabet (IPA)" lang="zxx">ɛfː ʃɑrp</span></a></span></span>]) ist eine <a href="Typsicherheit" title="Typsicherheit">typsichere</a> Multi-<a href="Programmierparadigma" title="Programmierparadigma">Paradigmen-</a>Sprache mit starkem Fokus auf <a href="Funktionale_Programmierung" title="Funktionale Programmierung">funktionale Programmierung</a> für das <a href=".Net-Framework" title=".Net-Framework">.Net-Framework</a>. Die Syntax ähnelt der von <a href="Objective_CAML" class="mw-redirect" title="Objective CAML">OCaml</a> sehr stark, da diese Sprache als Vorbild für die Implementierung der funktionalen und imperativen Sprachelemente diente. Im Gegensatz zu <a href="Objective_CAML" class="mw-redirect" title="Objective CAML">OCaml</a> hat F# kein strukturiertes <a href="Typisierung_(Informatik)" title="Typisierung (Informatik)">Typsystem</a>, sondern ein normatives, um bessere Kompatibilität mit <a href="C-Sharp" title="C-Sharp">C#</a> zu erreichen.
</p><p>Die objektorientierte Seite von F# ist deshalb auch signifikant anders als die in OCaml.
</p><p>F# ist voll interaktionsfähig mit allen anderen Sprachen des <a href=".NET_(Oberbegriff)" title=".NET (Oberbegriff)">.NET</a>-Systems und bietet durch das <a href=".Net-Framework" title=".Net-Framework">.Net-Framework</a> und <a href="Mono_(Software)" title="Mono (Software)">Mono</a> die Möglichkeit, den Code sowohl auf Windows als auch auf Linux, der <a href="Berkeley_Software_Distribution" title="Berkeley Software Distribution">BSD</a>- und <a href="Illumos" class="mw-redirect" title="Illumos">illumos</a>-Familie und <a href="MacOS" title="MacOS">macOS</a> einzusetzen. Via <a href="Xamarin" title="Xamarin">Xamarin</a> sind auch <a href="Android_(Betriebssystem)" title="Android (Betriebssystem)">Android</a> und iOS als Zielplattformen möglich.
</p><p>Ursprünglich wurde F# als Forschungsprojekt von <a href="Microsoft_Research" title="Microsoft Research">Microsoft Research</a> entwickelt, derzeit wird es von Microsofts Entwicklungsabteilung und der F# Software Foundation fortgeführt. F# wurde als Teil von <a href="Visual_Studio" title="Visual Studio">Visual Studio</a> 2010 erstmals offiziell unterstützt und mit ausgeliefert.<sup id="cite_ref-2" class="reference"><a href="#cite_note-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup> Im November 2010 wurde F# sowie zugehörige <a href="Compiler" title="Compiler">Compiler</a> und Bibliotheken unter der <a href="Apache-Lizenz_2.0" class="mw-redirect" title="Apache-Lizenz 2.0">Apache-Lizenz 2.0</a> freigegeben.
</p>
<div class="mw-heading mw-heading2"><h2 id="Einige_Sprachmerkmale">Einige Sprachmerkmale</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Werte">Werte</h3></div>
<p>In überwiegend imperativen Sprachen sind <a href="Variable_(Programmierung)" title="Variable (Programmierung)">Variablen</a> das primäre Sprachkonstrukt, um Werte zu speichern. Dies geschieht in funktional orientierten Programmiersprachen wie F# durch unveränderliche (englisch: „immutable“) Sprachkonstrukte. Mit dem häufig eingesetzten <a href="Schl%C3%BCsselwort_(Programmierung)" title="Schlüsselwort (Programmierung)">Schlüsselwort</a> <code>let</code> können Werte eines bestimmten Typs deklariert werden.
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">pi</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">3</span><span class="o">.</span><span class="mi">14159265</span>
<span class="k">let</span><span class="w"> </span><span class="nv">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">"John"</span>
</pre></div>
<p>F# bietet <a href="Typableitung" class="mw-redirect" title="Typableitung">Typableitung</a>, d. h. Typen von Ausdrücken werden automatisch ermittelt. Beispielsweise bekommt <code>pi</code> automatisch den Typ des <a href="Gleitkommazahl" title="Gleitkommazahl">Gleitkommazahl</a>-<a href="Literal" title="Literal">Literals</a> zugewiesen.
</p><p>Veränderliche Variablen sind mit dem <code>mutable</code> Schlüsselwort möglich und werden mit dem Zuweisungsoperator <code><-</code> verändert. Dies wird in den meisten Fällen nur selten getan, weil die beschriebene Unveränderlichkeit von Werten als passender zur Sprachphilosophie gesehen wird. Dies nennt sich in F# auch <i>functional first</i>, also „funktional-zuerst“.<sup id="cite_ref-3" class="reference"><a href="#cite_note-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">mutable</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">10</span>
<span class="n">x</span><span class="w"> </span><span class="o"><-</span><span class="w"> </span><span class="mi">15</span>
</pre></div>
<p>Werte im Nachhinein zu verändern, ist auch durch die Verwendung von sogenannten <i>reference cells</i> möglich:
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ref</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="c1">// x hat den Typ "int ref", ist also eine Referenz auf einen Integer</span>
<span class="n">x</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="mi">5</span><span class="w"> </span><span class="c1">// x wird ein neuer Wert zugewiesen</span>
<span class="n">printfn</span><span class="w"> </span><span class="s">"%i"</span><span class="w"> </span><span class="o">!</span><span class="n">x</span><span class="w"> </span><span class="c1">// Mittels des "!"-Operators wird x dereferenziert. Gibt 5 aus.</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Funktionen">Funktionen</h3></div>
<p>Funktionen werden wie andere Werte mit <code>let</code> deklariert und können Parameter erwarten:
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">square</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">x</span>
<span class="k">let</span><span class="w"> </span><span class="nv">add</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">y</span>
</pre></div>
<p>Funktionen können Funktionen als Parameter erwarten (siehe <a href="Funktion_h%C3%B6herer_Ordnung" title="Funktion höherer Ordnung">Funktion höherer Ordnung</a>):
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">do_twice</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="o">(</span><span class="n">f</span><span class="w"> </span><span class="n">x</span><span class="o">)</span>
</pre></div>
<p>Die Typen der Parameter werden automatisch erkannt, können aber auch explizit deklariert werden:
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">add</span><span class="w"> </span><span class="o">(</span><span class="n">x</span><span class="o">:</span><span class="w"> </span><span class="n">int</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">y</span><span class="o">:</span><span class="w"> </span><span class="n">int</span><span class="o">)</span><span class="w"> </span><span class="o">:</span><span class="n">int</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">y</span>
<span class="k">let</span><span class="w"> </span><span class="nv">do_twice</span><span class="w"> </span><span class="o">(</span><span class="n">f</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">int</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="n">int</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">x</span><span class="o">:</span><span class="w"> </span><span class="n">int</span><span class="o">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="o">(</span><span class="n">f</span><span class="w"> </span><span class="n">x</span><span class="o">)</span>
</pre></div>
<p>Die Anweisung
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="n">printfn</span><span class="w"> </span><span class="s">"%A"</span><span class="w"> </span><span class="o">(</span><span class="n">do_twice</span><span class="w"> </span><span class="n">square</span><span class="w"> </span><span class="mi">5</span><span class="o">)</span>
</pre></div>
<p>gibt 625 (das Quadrat des Quadrats von 5) aus. Die Funktion <code>do_twice</code> kann mit Hilfe des <a href="Komposition_(Mathematik)" title="Komposition (Mathematik)">Kompositionsoperators</a> und nach <a href="Eta-Reduktion" title="Eta-Reduktion">Eta-Reduktion</a> auch als
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">do_twice</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="o">>></span><span class="w"> </span><span class="n">f</span>
</pre></div>
<p>geschrieben werden.
</p><p>Im obigen Beispiel wird für <code>square</code> der Typ <code style="white-space:nowrap" class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="n">int</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="n">int</span></code> ermittelt, das heißt, <code>square</code> ist eine Funktion, die einen Parameter vom Typ <code>int</code> erwartet und einen Wert vom Typ <code>int</code> zurückgibt. Für <code class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="n">do_twice</span></code> erhält man den Typ <code style="white-space:nowrap" class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="o">(</span><span class="k">'</span><span class="n">a</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="k">'</span><span class="n">a</span><span class="o">)</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="k">'</span><span class="n">a</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="k">'</span><span class="n">a</span></code>. Dies bedeutet, <code>do_twice</code> ist eine Funktion, die als ersten Parameter einen Wert vom Typ <code style="white-space:nowrap" class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="o">(</span><span class="k">'</span><span class="n">a</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="k">'</span><span class="n">a</span><span class="o">)</span></code> (eine Funktion mit einem Parameter vom Typ <code class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="k">'</span><span class="n">a</span></code> und einem Rückgabewert vom Typ <code class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="k">'</span><span class="n">a</span></code>) bekommt. Als zweiten Parameter erhält sie einen Wert vom Typ <code class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="k">'</span><span class="n">a</span></code> und sie gibt einen Wert vom Typ <code class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="k">'</span><span class="n">a</span></code> zurück. <code class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="k">'</span><span class="n">a</span></code> hat hier die Rolle einer Typvariable (grob vergleichbar mit Generic- oder Template-Parametern in <a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Java</a>/<a href="C%2B%2B" title="C++">C++</a>, siehe <a href="Polymorphie_(Programmierung)" title="Polymorphie (Programmierung)">Polymorphie (Programmierung)</a>).
</p><p>In F# werden Parameter ohne Klammern etc., nur durch Leerzeichen getrennt, an die Funktion übergeben. Nur wenn als <a href="Parameter_(Informatik)" title="Parameter (Informatik)">Parameter</a> der Rückgabewert einer anderen Funktion benötigt wird, müssen Klammern gesetzt werden, um die Evaluierungsreihenfolge der Ausdrücke zu definieren. Bei <code style="white-space:nowrap" class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="n">printfn</span><span class="w"> </span><span class="s">"%A"</span><span class="w"> </span><span class="o">(</span><span class="n">add</span><span class="w"> </span><span class="mi">5</span><span class="w"> </span><span class="mi">8</span><span class="o">)</span></code> gehören die Werte 5 und 8 zur Funktion <code class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="n">add</span></code>; deren Rückgabewert ist ein Parameter für die Funktion <code class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><span class="n">printfn</span></code>.
</p><p>F# ermöglicht <a href="Closure_(Funktion)" title="Closure (Funktion)">Closures</a> und verwendet <a href="Currying" title="Currying">Currying</a> automatisch:
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">add</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">y</span>
<span class="k">let</span><span class="w"> </span><span class="nv">inc</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">add</span><span class="w"> </span><span class="mi">1</span>
</pre></div>
<p>In der Definition von <code>inc</code> wird der erste Parameter der Funktion <code>add</code> an den Wert 1 gebunden. Das Ergebnis dieser partiellen Funktionsanwendung ist eine neue Funktion mit nur noch einem Parameter. Die Auswertung des Ausdrucks
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="n">inc</span><span class="w"> </span><span class="mi">5</span>
</pre></div>
<p>liefert als Ergebnis 6.
</p><p>F# unterstützt <a href="Tupel_(Informatik)" title="Tupel (Informatik)">Tupel</a>:
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">u</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="w"> </span><span class="mi">6</span><span class="o">)</span>
<span class="k">let</span><span class="w"> </span><span class="nv">v</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">(</span><span class="mi">2</span><span class="o">,</span><span class="w"> </span><span class="o">-</span><span class="mi">3</span><span class="o">)</span>
<span class="k">let</span><span class="w"> </span><span class="nv">add</span><span class="w"> </span><span class="o">(</span><span class="n">a</span><span class="o">,</span><span class="w"> </span><span class="n">b</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">c</span><span class="o">,</span><span class="w"> </span><span class="n">d</span><span class="o">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">(</span><span class="n">a</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">c</span><span class="o">,</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">d</span><span class="o">)</span>
<span class="k">let</span><span class="w"> </span><span class="nv">x</span><span class="o">,</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">add</span><span class="w"> </span><span class="n">u</span><span class="w"> </span><span class="n">v</span>
</pre></div>
<p>F# bietet <i>Discriminated Unions</i><sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup> und <a href="Pattern_Matching" title="Pattern Matching">Pattern Matching</a>:
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">// Ein Element vom Typ Baum ist entweder ein "Ast" und enthält zwei Elemente vom Typ "Baum",</span>
<span class="c1">// oder es ist ein "Blatt" und enthält einen Integer</span>
<span class="k">type</span><span class="w"> </span><span class="nc">Baum</span><span class="w"> </span><span class="o">=</span>
<span class="o">|</span><span class="w"> </span><span class="n">Ast</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="n">Baum</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">Baum</span>
<span class="o">|</span><span class="w"> </span><span class="n">Blatt</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="n">int</span>
<span class="k">let</span><span class="w"> </span><span class="nv">rec</span><span class="w"> </span><span class="n">baumSumme</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span>
<span class="w"> </span><span class="k">match</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="k">with</span>
<span class="w"> </span><span class="o">|</span><span class="w"> </span><span class="n">Ast</span><span class="o">(</span><span class="n">l</span><span class="o">,</span><span class="w"> </span><span class="n">r</span><span class="o">)</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="n">baumSumme</span><span class="w"> </span><span class="n">l</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">baumSumme</span><span class="w"> </span><span class="n">r</span>
<span class="w"> </span><span class="o">|</span><span class="w"> </span><span class="n">Blatt</span><span class="o">(</span><span class="n">x</span><span class="o">)</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="n">x</span>
</pre></div>
<p>Ebenso gibt es Type Provider für die typsichere Verarbeitung externer Daten mit <a href="IntelliSense" title="IntelliSense">IntelliSense</a>.<sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup>
</p><p>In F# ist auch <a href="Objektorientierte_Programmierung" title="Objektorientierte Programmierung">objektorientiertes Programmieren</a> möglich. Beispiel für eine Klassendeklaration:
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">type</span><span class="w"> </span><span class="nc">Person</span><span class="w"> </span><span class="o">=</span>
<span class="w"> </span><span class="k">val</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="kt">string</span>
<span class="w"> </span><span class="k">val</span><span class="w"> </span><span class="k">mutable</span><span class="w"> </span><span class="n">age</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">int</span>
<span class="w"> </span><span class="k">new</span><span class="o">(</span><span class="n">n</span><span class="o">,</span><span class="w"> </span><span class="n">a</span><span class="o">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">{</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">n</span><span class="o">;</span><span class="w"> </span><span class="n">age</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">}</span>
<span class="w"> </span><span class="k">member</span><span class="w"> </span><span class="n">x</span><span class="p">.</span><span class="nf">Name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="o">.</span><span class="n">name</span>
<span class="w"> </span><span class="k">member</span><span class="w"> </span><span class="n">x</span><span class="p">.</span><span class="nf">Age</span>
<span class="w"> </span><span class="k">with</span><span class="w"> </span><span class="n">get</span><span class="bp">()</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="o">.</span><span class="n">age</span>
<span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="n">set</span><span class="o">(</span><span class="n">v</span><span class="o">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="o">.</span><span class="n">age</span><span class="w"> </span><span class="o"><-</span><span class="w"> </span><span class="n">v</span>
<span class="w"> </span><span class="k">member</span><span class="w"> </span><span class="n">x</span><span class="p">.</span><span class="nf">Print</span><span class="bp">()</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">printfn</span><span class="w"> </span><span class="s">"%s ist %i Jahre alt."</span><span class="w"> </span><span class="n">x</span><span class="o">.</span><span class="n">name</span><span class="w"> </span><span class="n">x</span><span class="o">.</span><span class="n">age</span>
</pre></div>
<p><a href="Zeiger_(Informatik)#Nullzeiger" title="Zeiger (Informatik)">Nullzeiger</a> werden nur für die Interaktion mit Klassen aus dem <a href=".Net-Framework" title=".Net-Framework">.Net-Framework</a> benötigt.
</p>
<div class="mw-heading mw-heading2"><h2 id="Syntax">Syntax</h2></div>
<p>Im F#-Code sind zwei Syntaxformen möglich: einfache Syntax und ausführliche Syntax. Die einfache Syntax wird standardmäßig verwendet.
</p><p>Beispiel für die einfache und ausführliche Syntax:
</p>
<table class="wikitable toptextcells">
<tbody><tr>
<th>einfache Syntax</th>
<th>ausführliche Syntax
</th></tr>
<tr>
<td>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">mutable</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
<span class="k">while</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="mi">3</span><span class="w"> </span><span class="k">do</span>
<span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o"><-</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
</pre></div>
</td>
<td>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">mutable</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
<span class="k">while</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="mi">3</span><span class="w"> </span><span class="k">do</span>
<span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o"><-</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="k">done</span>
</pre></div>
</td></tr>
<tr>
<td>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">type</span><span class="w"> </span><span class="nc">Person</span><span class="w"> </span><span class="o">=</span>
<span class="w"> </span><span class="k">val</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="kt">string</span>
<span class="w"> </span><span class="k">val</span><span class="w"> </span><span class="k">mutable</span><span class="w"> </span><span class="n">age</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">int</span>
</pre></div>
</td>
<td>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">type</span><span class="w"> </span><span class="nc">Person</span><span class="w"> </span><span class="o">=</span>
<span class="k">class</span>
<span class="w"> </span><span class="k">val</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="kt">string</span>
<span class="w"> </span><span class="k">val</span><span class="w"> </span><span class="k">mutable</span><span class="w"> </span><span class="n">age</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">int</span>
<span class="k">end</span>
</pre></div>
</td></tr></tbody></table>
<p>Bei der einfachen Syntax sind die Einrückungen zwingend erforderlich, bei der ausführlichen könnte man sie auch weglassen.
</p>
<div class="mw-heading mw-heading2"><h2 id="Entwicklungsumgebung_und_Compiler">Entwicklungsumgebung und Compiler</h2></div>
<p>F#-Code wird <a href="Compiler" title="Compiler">kompiliert</a>, hierbei entsteht <a href="Zwischencode" title="Zwischencode">Zwischencode</a> in der <a href="Common_Intermediate_Language" title="Common Intermediate Language">Common Intermediate Language</a> (CIL), genau wie bei Programmen, die in <a href="C-Sharp" title="C-Sharp">C#</a> oder <a href="VB.NET" class="mw-redirect" title="VB.NET">VB.NET</a> geschrieben wurden.
</p><p>Es gibt auch eine interaktive Umgebung bzw. F#-<a href="Interpreter" title="Interpreter">Interpreter</a>, F# Interactive oder kurz FSI. Damit kann man den Code direkt in der <a href="Kommandozeile" title="Kommandozeile">Konsole</a> schreiben. Eingaben im Interpreter sind mit <code>;;</code> abzuschließen, wodurch auch mehrzeilige Eingaben ermöglicht werden. Nach dem Kompilieren führt F# Interactive den Code aus und schreibt die Signatur aller kompilierten Typen und Werte in das Konsolenfenster. Auch Fehlermeldungen werden so ausgegeben.<sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup>
</p><p>Dieser Interpreter erlaubt in unterstützten Editoren wie <a href="Visual_Studio_Code" title="Visual Studio Code">Visual Studio Code</a> die Ausführung von Code ohne vorherige Kompilierung, so wie dies von dynamischen Sprachen bekannt ist.
</p><p>Außerdem gibt es den Fable<sup id="cite_ref-7" class="reference"><a href="#cite_note-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup>-Übersetzer, mit dessen Hilfe sich F#-Code in <a href="JavaScript" title="JavaScript">JavaScript</a>, <a href="Rust_(Programmiersprache)" title="Rust (Programmiersprache)">Rust</a>, <a href="Python_(Programmiersprache)" title="Python (Programmiersprache)">Python</a>, <a href="PHP" title="PHP">PHP</a> und <a href="Dart_(Programmiersprache)" title="Dart (Programmiersprache)">Dart</a> übersetzen lässt.
</p>
<div class="mw-heading mw-heading2"><h2 id="Beispiele">Beispiele</h2></div>
<p>Folgende Beispiele geben „<a href="Hello_World" class="mw-redirect" title="Hello World">Hello World</a>“ aus.
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">main</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nn">System</span><span class="p">.</span><span class="nn">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="o">(</span><span class="s">"Hello World"</span><span class="o">)</span>
</pre></div>
<p>oder
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="n">printfn</span><span class="w"> </span><span class="s">"Hello World"</span>
</pre></div>
<p>Die folgende Funktion implementiert die rekursive <a href="Ackermannfunktion" title="Ackermannfunktion">Ackermannfunktion</a>:
</p>
<div class="mw-highlight mw-highlight-lang-fsharp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">let</span><span class="w"> </span><span class="nv">rec</span><span class="w"> </span><span class="n">ack</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="k">then</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="k">then</span><span class="w"> </span><span class="n">ack</span><span class="w"> </span><span class="o">(</span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="o">)</span><span class="w"> </span><span class="mi">1</span>
<span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="n">ack</span><span class="w"> </span><span class="o">(</span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">ack</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">(</span><span class="n">n</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="o">))</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Literatur">Literatur</h2></div>
<ul><li>Oliver Sturm: <i>F# Einstieg und praktische Anwendung</i>. entwickler.press, 2012, ISBN 978-3-86802-083-0.</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Weblinks">Weblinks</h2></div>
<ul><li><span class="cite"><a rel="nofollow" class="external text" href="http://fsharp.org/"><i>The F# Software Foundation.</i></a><span class="Abrufdatum"> Abgerufen am 5. Juni 2014</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=The+F%23+Software+Foundation&rft.description=The+F%23+Software+Foundation&rft.identifier=http%3A%2F%2Ffsharp.org%2F&rft.language=en"> </span></li>
<li><span class="cite"><a rel="nofollow" class="external text" href="https://docs.microsoft.com/de-de/dotnet/fsharp/"><i>F# Dokumentation.</i></a> In: <i>Microsoft Docs.</i> Microsoft,<span class="Abrufdatum"> abgerufen am 27. April 2014</span>.</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=F%23+Dokumentation&rft.description=F%23+Dokumentation&rft.identifier=https%3A%2F%2Fdocs.microsoft.com%2Fde-de%2Fdotnet%2Ffsharp%2F&rft.publisher=Microsoft"> </span></li>
<li><span class="cite"><a rel="nofollow" class="external text" href="https://github.com/dotnet/fsharp"><i>F# compiler, Basisbibliothek und Tools auf GitHub.</i></a><span class="Abrufdatum"> Abgerufen am 9. Juni 2020</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=F%23+compiler%2C+Basisbibliothek+und+Tools+auf+GitHub&rft.description=F%23+compiler%2C+Basisbibliothek+und+Tools+auf+GitHub&rft.identifier=https%3A%2F%2Fgithub.com%2Fdotnet%2Ffsharp&rft.language=en"> </span></li>
<li><span class="cite"><a rel="nofollow" class="external text" href="http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/default.aspx"><i>F# at Microsoft Research.</i></a> Microsoft Research,<span class="Abrufdatum"> abgerufen am 27. April 2014</span> (englisch, F#-Homepage von Microsoft Research).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=F%23+at+Microsoft+Research&rft.description=F%23+at+Microsoft+Research&rft.identifier=http%3A%2F%2Fresearch.microsoft.com%2Fen-us%2Fum%2Fcambridge%2Fprojects%2Ffsharp%2Fdefault.aspx&rft.publisher=Microsoft+Research&rft.language=en"> </span></li>
<li><span class="cite"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20110715231625/http://www.ctocorner.com/fsharp/book/default.aspx"><i>The F# Survival Guide.</i></a> CTO Corner, archiviert vom <style data-mw-deduplicate="TemplateStyles:r250917974">
/* start https://de.wikipedia.org/ */
.mw-parser-output .dewiki-iconexternal>a{background-position:center right!important;background-repeat:no-repeat!important}body.skin-minerva .mw-parser-output .dewiki-iconexternal>a{background-image:url("./_mw_/OOjs_UI_icon_external-link-ltr-progressive.svg")!important;background-size:10px!important;padding-right:13px!important}body.skin-timeless .mw-parser-output .dewiki-iconexternal>a,body.skin-monobook .mw-parser-output .dewiki-iconexternal>a{background-image:url("./_mw_/MediaWiki_external_link_icon.svg")!important;padding-right:13px!important}body.skin-vector .mw-parser-output .dewiki-iconexternal>a{background-image:url("./_mw_/Link.ernal-small-ltr-progressive.svg")!important;background-size:0.857em!important;padding-right:1em!important}
/* end https://de.wikipedia.org/ */
</style><span class="dewiki-iconexternal"><a class="external text" href="https://redirecter.toolforge.org/?url=http%3A%2F%2Fwww.ctocorner.com%2Ffsharp%2Fbook%2Fdefault.aspx">Original</a></span> am <span style="white-space:nowrap;">15. Juli 2011</span><span>;</span><span class="Abrufdatum"> abgerufen am 27. April 2014</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=The+F%23+Survival+Guide&rft.description=The+F%23+Survival+Guide&rft.identifier=https%3A%2F%2Fweb.archive.org%2Fweb%2F20110715231625%2Fhttp%3A%2F%2Fwww.ctocorner.com%2Ffsharp%2Fbook%2Fdefault.aspx&rft.publisher=CTO+Corner&rft.source=http://www.ctocorner.com/fsharp/book/default.aspx&rft.language=en"> </span></li>
<li><span class="cite"><a rel="nofollow" class="external text" href="http://dungpa.github.io/fsharp-cheatsheet/"><i>F# Cheatsheet.</i></a> In: <i>Github.</i><span class="Abrufdatum"> Abgerufen am 9. Juni 2020</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=F%23+Cheatsheet&rft.description=F%23+Cheatsheet&rft.identifier=http%3A%2F%2Fdungpa.github.io%2Ffsharp-cheatsheet%2F&rft.language=en"> </span></li>
<li><span class="cite">Scott Wlaschin: <a rel="nofollow" class="external text" href="http://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work/"><i>Twenty six low-risk ways to use F# at work.</i></a> In: <i>F# for fun and profit.</i> 20. April 2014,<span class="Abrufdatum"> abgerufen am 9. Juni 2020</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=Twenty+six+low-risk+ways+to+use+F%23+at+work&rft.description=Twenty+six+low-risk+ways+to+use+F%23+at+work&rft.identifier=http%3A%2F%2Ffsharpforfunandprofit.com%2Fposts%2Flow-risk-ways-to-use-fsharp-at-work%2F&rft.creator=Scott+Wlaschin&rft.date=2014-04-20&rft.language=en"> </span></li>
<li><span class="cite"><a rel="nofollow" class="external text" href="https://try.fsharp.org/"><i>Try F#.</i></a> F# Software Foundation,<span class="Abrufdatum"> abgerufen am 9. Juni 2020</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=Try+F%23&rft.description=Try+F%23&rft.identifier=https%3A%2F%2Ftry.fsharp.org%2F&rft.publisher=F%23+Software+Foundation&rft.language=en"> </span> Interaktives Tutorial.</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Belege">Belege</h2></div>
<ol class="references">
<li id="cite_note-1"><span class="mw-cite-backlink"><a href="#cite_ref-1">↑</a></span> <span class="reference-text"><span class="cite"><a rel="nofollow" class="external text" href="https://devblogs.microsoft.com/dotnet/announcing-fsharp-7/"><i>Announcing F# 7.</i></a> 9. November 2021,<span class="Abrufdatum"> abgerufen am 14. September 2023</span> (amerikanisches Englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=Announcing+F%23+7&rft.description=Announcing+F%23+7&rft.identifier=https%3A%2F%2Fdevblogs.microsoft.com%2Fdotnet%2Fannouncing-fsharp-7%2F&rft.date=2021-11-09&rft.language=en-US"> </span></span>
</li>
<li id="cite_note-2"><span class="mw-cite-backlink"><a href="#cite_ref-2">↑</a></span> <span class="reference-text"><a rel="nofollow" class="external text" href="http://blogs.msdn.com/dsyme/archive/2008/12/10/fsharp-to-ship-as-part-of-visual-studio-2010.aspx"><i>F# to ship as part of Visual Studio 2010</i>.</a> Don Syme’s WebLog on the F# Language and Related Topics</span>
</li>
<li id="cite_note-3"><span class="mw-cite-backlink"><a href="#cite_ref-3">↑</a></span> <span class="reference-text"><span class="cite"><a rel="nofollow" class="external text" href="https://slideslive.com/38904441/functionalfirst-programming-with-f?ref=og-meta-tags"><i>Functional-first Programming with F#.</i></a><span class="Abrufdatum"> Abgerufen am 14. September 2023</span> (amerikanisches Englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=Functional-first+Programming+with+F%23&rft.description=Functional-first+Programming+with+F%23&rft.identifier=https%3A%2F%2Fslideslive.com%2F38904441%2Ffunctionalfirst-programming-with-f%3Fref%3Dog-meta-tags&rft.language=en-US"> </span></span>
</li>
<li id="cite_note-4"><span class="mw-cite-backlink"><a href="#cite_ref-4">↑</a></span> <span class="reference-text"><a rel="nofollow" class="external text" href="https://learn.microsoft.com/de-de/dotnet/fsharp/language-reference/discriminated-unions">Unterscheidungs-Unions</a>, auf learn.microsoft.com</span>
</li>
<li id="cite_note-5"><span class="mw-cite-backlink"><a href="#cite_ref-5">↑</a></span> <span class="reference-text"><a rel="nofollow" class="external text" href="https://docs.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers/">Type Provider</a></span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><a href="#cite_ref-6">↑</a></span> <span class="reference-text"><a rel="nofollow" class="external text" href="http://msdn.microsoft.com/de-de/library/dd233175.aspx">Microsoft F# Interactive-Referenz</a></span>
</li>
<li id="cite_note-7"><span class="mw-cite-backlink"><a href="#cite_ref-7">↑</a></span> <span class="reference-text"><span class="cite"><a rel="nofollow" class="external text" href="https://fable.io/"><i>Fable · JavaScript you can be proud of!</i></a><span class="Abrufdatum"> Abgerufen am 14. September 2023</span>.</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AF-Sharp&rft.title=Fable+%C2%B7+JavaScript+you+can+be+proud+of%21&rft.description=Fable+%C2%B7+JavaScript+you+can+be+proud+of%21&rft.identifier=https%3A%2F%2Ffable.io%2F"> </span></span>
</li>
</ol>
<div class="hintergrundfarbe1 rahmenfarbe1 navigation-not-searchable normdaten-typ-s" style="border-style: solid; border-width: 1px; clear: left; margin-bottom:1em; margin-top:1em; padding: 0.25em; overflow: hidden; word-break: break-word; word-wrap: break-word;" id="normdaten">
<div style="display: table-cell; vertical-align: middle; width: 100%;">
<div>
Normdaten (Sachbegriff): <a href="Gemeinsame_Normdatei" title="Gemeinsame Normdatei">GND</a>: <span class="-print"><a rel="nofollow" class="external text" href="https://d-nb.info/gnd/7578680-1">7578680-1</a></span> </div>
</div></div></div><!--htdig_noindex--><div><div class="zim-footer">
Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-03-22" href="https://de.wikipedia.org/wiki/?title=F-Sharp&oldid=254447959">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>
</body></html>